⚡️ Speed up function `_wrap_repr` by 82% #56

codeflash-ai · 2025-12-02T05:29:09Z

📄 82% (0.82x) speedup for `_wrap_repr` in `xarray/datatree_/datatree/formatting_html.py`

⏱️ Runtime : 104 microseconds → 57.1 microseconds (best of 94 runs)

📝 Explanation and details

The optimized version achieves an 81% speedup by eliminating the expensive "".join() operation on a 27-element list and replacing it with direct string concatenation using f-string formatting.

Key optimizations applied:

Eliminated list construction and join: The original code created a 27-element list of string literals and then called "".join() on it. The optimized version uses Python's automatic string literal concatenation within parentheses, which happens at compile time rather than runtime.
Reduced string operations: Instead of 27 separate string objects being joined at runtime, the optimized version creates one large string template with only 2 variable interpolations (height and r).
Minor conditional optimization: Changed end is False to not end for slightly better performance.

Why this leads to speedup:

"".join() on many small strings requires Python to iterate through the list, calculate total length, allocate a new string buffer, and copy each element
String literal concatenation in parentheses is optimized by Python's compiler into a single string constant
The line profiler shows the join operation took 16.6% of total time in the original, which is completely eliminated

Impact on workloads:
Based on the function reference, _wrap_repr is called in a loop within summarize_children() for each child node in a data tree structure. This means the 81% speedup will be multiplied across potentially many child nodes, making tree rendering significantly faster. The test results show consistent 50-100% speedups across all test cases, with larger inputs still benefiting substantially (54-68% faster for large-scale tests).

The optimization is particularly effective for this HTML templating use case where most of the output is static markup with only a few dynamic variables.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 61 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from xarray.datatree_.datatree.formatting_html import _wrap_repr

# unit tests

# ---- Basic Test Cases ----


def test_basic_html_wrapping():
    # Test with a simple HTML string
    input_html = "<li>Title</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.72μs -> 894ns (92.1% faster)


def test_basic_end_false():
    # Test with end=False, should set height to "100%"
    input_html = "<li>Details</li>"
    codeflash_output = _wrap_repr(input_html, end=False)
    result = codeflash_output  # 1.95μs -> 1.02μs (91.3% faster)


def test_basic_end_true():
    # Test with end=True, should set height to "1.2em"
    input_html = "<li>Details</li>"
    codeflash_output = _wrap_repr(input_html, end=True)
    result = codeflash_output  # 1.90μs -> 1.07μs (77.7% faster)


def test_basic_end_default():
    # Default value for end should be True
    input_html = "<li>Default</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.68μs -> 889ns (89.3% faster)


def test_basic_multiple_list_items():
    # Test with multiple HTML list items
    input_html = "<li>One</li><li>Two</li><li>Three</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.69μs -> 865ns (95.0% faster)


# ---- Edge Test Cases ----


def test_empty_string():
    # Edge case: empty string should still wrap properly
    input_html = ""
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.70μs -> 898ns (88.9% faster)


def test_whitespace_string():
    # Edge case: whitespace only string
    input_html = "   "
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.67μs -> 844ns (97.4% faster)


def test_special_characters():
    # Edge case: HTML with special characters
    input_html = "<li>& < > \" ' /</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.67μs -> 850ns (96.8% faster)


def test_non_html_string():
    # Edge case: non-HTML string
    input_html = "plain text"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.66μs -> 895ns (85.6% faster)


def test_boolean_end_variants():
    # Edge case: end parameter as different truthy/falsy values
    input_html = "<li>Test</li>"
    # Pass end as 0
    codeflash_output = _wrap_repr(input_html, end=0)
    result = codeflash_output  # 1.96μs -> 1.14μs (71.1% faster)
    # Pass end as 1
    codeflash_output = _wrap_repr(input_html, end=1)
    result = codeflash_output  # 849ns -> 521ns (63.0% faster)
    # Pass end as None (should default to False)
    codeflash_output = _wrap_repr(input_html, end=None)
    result = codeflash_output  # 555ns -> 342ns (62.3% faster)


def test_html_with_nested_tags():
    # Edge case: HTML with nested tags
    input_html = "<li><span>Nested</span></li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.61μs -> 789ns (104% faster)


def test_long_string_with_newlines():
    # Edge case: string containing newlines
    input_html = "<li>Line1\nLine2\nLine3</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.66μs -> 859ns (92.9% faster)


def test_html_with_unicode_characters():
    # Edge case: HTML with unicode characters
    input_html = "<li>Ω≈ç√∫˜µ≤≥÷</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 2.33μs -> 1.23μs (89.3% faster)


def test_html_with_escaped_characters():
    # Edge case: HTML with escaped characters
    input_html = "<li>&amp;&lt;&gt;&quot;&apos;</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.71μs -> 842ns (103% faster)


def test_html_with_script_tag():
    # Edge case: HTML containing a script tag
    input_html = "<li><script>alert('x')</script></li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.56μs -> 875ns (78.1% faster)


# ---- Large Scale Test Cases ----


def test_large_number_of_list_items():
    # Large scale: wrap 500 list items
    input_html = "".join(f"<li>Item {i}</li>" for i in range(500))
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.92μs -> 1.18μs (62.2% faster)


def test_large_html_string_length():
    # Large scale: wrap a very large HTML string (length ~5000)
    input_html = "<li>" + "a" * 4990 + "</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.89μs -> 1.12μs (68.8% faster)


def test_large_html_with_newlines_and_tabs():
    # Large scale: large HTML string with newlines and tabs
    input_html = "".join(f"<li>\tItem {i}\n</li>" for i in range(1000))
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 2.26μs -> 1.45μs (56.0% faster)


def test_performance_large_scale():
    # Large scale: ensure function doesn't error on large input
    input_html = "".join(f"<li>Item {i}</li>" for i in range(999))
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 2.13μs -> 1.33μs (60.9% faster)


def test_large_scale_end_false():
    # Large scale: test with end=False
    input_html = "".join(f"<li>Item {i}</li>" for i in range(500))
    codeflash_output = _wrap_repr(input_html, end=False)
    result = codeflash_output  # 2.14μs -> 1.34μs (60.0% faster)


# ---- Additional Robustness Tests ----


def test_html_with_comments():
    # Test HTML with comments
    input_html = "<li><!-- comment --></li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.71μs -> 869ns (97.0% faster)


def test_html_with_doctype():
    # Test HTML with doctype declaration
    input_html = "<!DOCTYPE html><li>DocType</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.62μs -> 876ns (84.5% faster)


def test_html_with_empty_ul():
    # Test for empty <ul> tag inside input (should not affect wrapper)
    input_html = "<ul></ul>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.74μs -> 864ns (101% faster)


def test_html_with_multiple_ul_tags():
    # Test for multiple <ul> tags in input
    input_html = "<ul><li>One</li></ul><ul><li>Two</li></ul>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 1.63μs -> 877ns (86.0% faster)


def test_html_with_non_ascii_whitespace():
    # Edge case: input with non-ASCII whitespace
    input_html = "<li>\u2003Item\u2009</li>"
    codeflash_output = _wrap_repr(input_html)
    result = codeflash_output  # 2.36μs -> 1.23μs (92.2% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from xarray.datatree_.datatree.formatting_html import _wrap_repr

# unit tests

# ----------- BASIC TEST CASES -----------


def test_basic_html_wrapping():
    # Basic HTML string
    html_in = "<li>Test</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.71μs -> 914ns (86.5% faster)


def test_basic_end_false():
    # Basic HTML string with end=False
    html_in = "<li>End False</li>"
    codeflash_output = _wrap_repr(html_in, end=False)
    wrapped = codeflash_output  # 1.78μs -> 1.03μs (72.5% faster)


def test_basic_end_true():
    # Basic HTML string with end=True
    html_in = "<li>End True</li>"
    codeflash_output = _wrap_repr(html_in, end=True)
    wrapped = codeflash_output  # 1.93μs -> 1.03μs (87.4% faster)


def test_basic_end_default():
    # Default end parameter should be True
    html_in = "<li>Default End</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.71μs -> 870ns (96.3% faster)


def test_basic_multiple_li():
    # Multiple list items
    html_in = "<li>One</li><li>Two</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.62μs -> 835ns (93.8% faster)


# ----------- EDGE TEST CASES -----------


def test_empty_string():
    # Edge case: empty string
    html_in = ""
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.72μs -> 884ns (94.9% faster)


def test_whitespace_string():
    # Edge case: whitespace only
    html_in = "   "
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.67μs -> 894ns (86.6% faster)


def test_non_html_string():
    # Edge case: plain text, not HTML
    html_in = "plain text"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.72μs -> 852ns (102% faster)


def test_special_characters():
    # Edge case: string with HTML special characters
    html_in = "<li>&lt;Test &amp; Validate&gt;</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.61μs -> 825ns (95.6% faster)


def test_unicode_characters():
    # Edge case: unicode characters
    html_in = "<li>Διαφορετικό</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 2.31μs -> 1.20μs (93.5% faster)


def test_multiline_html():
    # Edge case: multiline HTML
    html_in = "<li>Line1</li>\n<li>Line2</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.67μs -> 821ns (103% faster)


def test_end_parameter_various_types():
    # Edge case: end parameter as different types
    html_in = "<li>Type Test</li>"
    # Should coerce truthy/falsy values to bool
    codeflash_output = _wrap_repr(html_in, end=1)  # 1.92μs -> 1.11μs (72.9% faster)
    codeflash_output = _wrap_repr(html_in, end="yes")  # 889ns -> 545ns (63.1% faster)
    codeflash_output = _wrap_repr(html_in, end=0)  # 595ns -> 390ns (52.6% faster)
    codeflash_output = _wrap_repr(html_in, end=None)  # 502ns -> 330ns (52.1% faster)
    codeflash_output = _wrap_repr(html_in, end=True)  # 460ns -> 297ns (54.9% faster)
    codeflash_output = _wrap_repr(html_in, end=False)  # 474ns -> 286ns (65.7% faster)


def test_html_with_nested_tags():
    # Edge case: HTML with nested tags
    html_in = "<li><span>Nested</span></li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.64μs -> 839ns (95.1% faster)


def test_html_with_attributes():
    # Edge case: HTML with attributes in tags
    html_in = "<li class='item' id='test'>Attr</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.67μs -> 728ns (130% faster)


# ----------- LARGE SCALE TEST CASES -----------


def test_large_html_input():
    # Large scale: many list items
    html_in = "".join([f"<li>Item {i}</li>" for i in range(1000)])
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 2.15μs -> 1.40μs (54.1% faster)


def test_large_multiline_html_input():
    # Large scale: many multiline items
    html_in = "\n".join([f"<li>Item {i}</li>" for i in range(1000)])
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 2.21μs -> 1.39μs (59.7% faster)


def test_large_unicode_html_input():
    # Large scale: many unicode items
    html_in = "".join([f"<li>Δοκιμή {i}</li>" for i in range(1000)])
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 3.18μs -> 2.13μs (49.0% faster)


def test_performance_large_input():
    # Performance test: ensure function completes quickly for large input
    import time

    html_in = "".join([f"<li>Perf {i}</li>" for i in range(1000)])
    start = time.time()
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 2.12μs -> 1.28μs (65.7% faster)
    duration = time.time() - start


# ----------- ADDITIONAL EDGE CASES -----------


def test_html_with_script_tag():
    # Edge case: HTML with script tag
    html_in = "<li>Safe</li><script>alert('x');</script>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.68μs -> 877ns (91.0% faster)


def test_html_with_comment():
    # Edge case: HTML with comment
    html_in = "<li>Item</li><!-- comment -->"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.64μs -> 854ns (92.3% faster)


def test_html_with_empty_ul():
    # Edge case: input is already an empty ul
    html_in = "<ul></ul>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.65μs -> 937ns (75.6% faster)


def test_html_with_long_string():
    # Edge case: very long string input
    html_in = "<li>" + "A" * 1000 + "</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.99μs -> 1.23μs (62.0% faster)


def test_html_with_non_ascii():
    # Edge case: non-ASCII characters
    html_in = "<li>你好，世界</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 2.22μs -> 1.26μs (76.3% faster)


def test_html_with_escaped_characters():
    # Edge case: escaped HTML entities
    html_in = "<li>&amp;&lt;&gt;&quot;&apos;</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.65μs -> 804ns (105% faster)


def test_html_with_no_li_tags():
    # Edge case: input with no <li> tags
    html_in = "No list items here"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.73μs -> 860ns (101% faster)


def test_html_with_only_li_tags():
    # Edge case: input with only <li> tags and no content
    html_in = "<li></li><li></li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.67μs -> 858ns (94.6% faster)


def test_html_with_mixed_content():
    # Edge case: input with mixed HTML and plain text
    html_in = "<li>HTML</li>PlainText<li>More HTML</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.52μs -> 807ns (88.6% faster)


def test_html_with_newlines_and_tabs():
    # Edge case: input with newlines and tabs
    html_in = "<li>Item1</li>\n\t<li>Item2</li>"
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.65μs -> 830ns (98.8% faster)


def test_html_with_large_whitespace():
    # Edge case: input with lots of whitespace
    html_in = " " * 500
    codeflash_output = _wrap_repr(html_in)
    wrapped = codeflash_output  # 1.77μs -> 911ns (94.7% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from xarray.datatree_.datatree.formatting_html import _wrap_repr

def test__wrap_repr():
    _wrap_repr('', end=False)

def test__wrap_repr_2():
    _wrap_repr('', end=True)

Timer unit: 1e-09 s

To edit these changes git checkout codeflash/optimize-_wrap_repr-mio51b5m and push.

The optimized version achieves an **81% speedup** by eliminating the expensive `"".join()` operation on a 27-element list and replacing it with direct string concatenation using f-string formatting. **Key optimizations applied:** 1. **Eliminated list construction and join**: The original code created a 27-element list of string literals and then called `"".join()` on it. The optimized version uses Python's automatic string literal concatenation within parentheses, which happens at compile time rather than runtime. 2. **Reduced string operations**: Instead of 27 separate string objects being joined at runtime, the optimized version creates one large string template with only 2 variable interpolations (`height` and `r`). 3. **Minor conditional optimization**: Changed `end is False` to `not end` for slightly better performance. **Why this leads to speedup:** - `"".join()` on many small strings requires Python to iterate through the list, calculate total length, allocate a new string buffer, and copy each element - String literal concatenation in parentheses is optimized by Python's compiler into a single string constant - The line profiler shows the join operation took 16.6% of total time in the original, which is completely eliminated **Impact on workloads:** Based on the function reference, `_wrap_repr` is called in a loop within `summarize_children()` for each child node in a data tree structure. This means the 81% speedup will be multiplied across potentially many child nodes, making tree rendering significantly faster. The test results show consistent 50-100% speedups across all test cases, with larger inputs still benefiting substantially (54-68% faster for large-scale tests). The optimization is particularly effective for this HTML templating use case where most of the output is static markup with only a few dynamic variables.

codeflash-ai bot requested a review from mashraf-222 December 2, 2025 05:29

codeflash-ai bot added ⚡️ codeflash Optimization PR opened by Codeflash AI 🎯 Quality: High Optimization Quality according to Codeflash labels Dec 2, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

⚡️ Speed up function `_wrap_repr` by 82% #56

⚡️ Speed up function `_wrap_repr` by 82% #56

Uh oh!

codeflash-ai bot commented Dec 2, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

⚡️ Speed up function _wrap_repr by 82% #56

Are you sure you want to change the base?

⚡️ Speed up function _wrap_repr by 82% #56

Uh oh!

Conversation

codeflash-ai bot commented Dec 2, 2025

📄 82% (0.82x) speedup for _wrap_repr in xarray/datatree_/datatree/formatting_html.py

📝 Explanation and details

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

⚡️ Speed up function `_wrap_repr` by 82% #56

⚡️ Speed up function `_wrap_repr` by 82% #56

📄 82% (0.82x) speedup for `_wrap_repr` in `xarray/datatree_/datatree/formatting_html.py`